import sys

# print 是一个打印方法
print("这是一个测试")

# 基础数据类型
# int float string bool Tuple(元组)  =>不可变数据
# list(列表)  Set(集合) Dictionary(字典) =>可变数据

# testInt = 100
# testFloat = 100.0
# testStr = "100"
# testbool = 2 > 1

# print(testInt, type(testInt))
# print(testFloat, type(testFloat))
# print(testStr, type(testStr))
# print(testbool, type(testbool))

# var_tuple = (0, 1, 2)
# var_list = [0, 1, 2]
# var_Set = {0, 1, 2}
# var_Dict = {"0": 1, "1": "C"}
# print(var_tuple, type(var_tuple))
# print(var_list, type(var_list))
# print(var_Set, type(var_Set))
# print(var_Dict, type(var_Dict))

# 切片 变量[start : end : step]
# var_Str = "thisisateat"
# print(var_Str[2:9:2])

# 类
# class Test(object):
#     def __new__(cls) -> Self:
#         return super().__new__(cls)

#     def __init__(self):  # 初始化
#         print("这是 init ()")

# test = Test()

# __new__() object基类内置方法


# 单例模式 =>  优点： 节省内存  缺点 ： 多线程访问容易引发线程安全
class SingleTest(object):

    obj = None

    def __new__(cls):
        if cls.obj == None:
            cls.obj = super().__new__(cls)
        return cls.obj

    def __init__(self):
        print("init")


var0 = SingleTest()
var1 = SingleTest()
print(var0)
print(var1)

# 实现单例 内存地址都是同一个
# 重写__new__()实现单例
# 1=> 定义一个类属性，初始化为None ,记录单例对象的引用
# 2=> 重写__new__()


# 导入模块实现单例   模块就是天然的单例
class SingleTest0(object):
    pass


# form SingleTest0  import te as te01
# form SingleTest0  import te as te02

# 单例的应用


class Person(object):
    """人类 ---人类的描述信息 """  # 只能使用多行注释，单行注释无效


per = Person()
print(per.__doc__)

# => __xx__ 魔法属性
# __doc__ 当前操作对象的描述
#  __module__ 当前操作对象所在的模块
#  __mlass__ 当前操作对象所在的类
#  __str__  必须要有返回值 ，且一定是string 类型
#  __del__()  析构函数 程序结束，或者删除某个对象时调用
#  __call__() 实力对象成为一个可调用对象
# 可调用对象 ：
# callable() : 判断一个 对象是否是可调用对象
